package fanxing20230413;

import sun.security.timestamp.TSRequest;
//lambda表达式在集合中的使用
import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

@FunctionalInterface
interface NoparameterNoReturn {
    void test();
    /*static void text2() {

    }
    default void text3() {

    }*/
    //接口中可以有static方法，可以有default方法，但是只能有一个抽象方法
}
//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
    void test(int a);
}
//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
    void test(int a,double b);
}
//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}
//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
    int test(int a);
}
//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
    int test(int a,int b);
}
public class Text {
    public static void main(String[] args) {
        Map<String,Integer> hashMap = new HashMap<>();
        hashMap.put("hello",3);
        hashMap.put("this",8);
        hashMap.put("abcdf",7);
        /*hashMap.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println("key: "+s+" value: "+integer);
            }
        });*/
        //Lambda表达式就相当于只有几个参数然后指向被用于做什么，没有方法这些东西
        hashMap.forEach((s,integer)->
                System.out.println("key: "+s+" value: "+integer));
    }
    public static void main5(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("abcd");
        list.add("this");
        list.add("day");
        /*foreach方法：是一个Consumer接口接收一个对象，
        这个对象一定是实现了这个接口并且重写了accept方法的，
        */
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        System.out.println("=============");
        list.forEach(s-> System.out.println(s));
        System.out.println("=============");
        /*sort方法也是一个Comparator接口接收一个对象，所以这个对象要实现这个接口
        * 重写里边的compareTo方法*/
        /*list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });*/
        list.sort((o1, o2) -> {return o1.compareTo(o2);});
        list.forEach(s -> System.out.println(s));
    }
    public static void main4(String[] args) {
        //变量的捕获，在main方法中有一个变量a，在匿名内部类中打印了a，就说在匿名内部类中捕获到了a
        //但是此时捕获的a一定是一个常量或者是从未被修改过的量
        int a = 100;
        NoparameterNoReturn noParameterNoReturn = new NoparameterNoReturn() {
            //a = 200;
            @Override
            public void test() {
                System.out.println("hello"+a);
            }
        };
    }
    public static void main3(String[] args) {
        //下面的return和{}都可以省略，因为只有一个返回值   有一个参数时也可以省略（）
        NoParameterReturn noParameterReturn = ()->{return 10;};
        int ret = noParameterReturn.test();
        System.out.println(ret);

        OneParameterReturn oneParameterReturn = x-> x+10;
        ret = oneParameterReturn.test(25);
        System.out.println(ret);

        MoreParameterReturn moreParameterReturn = (x,y)-> x*y+1;
        ret = moreParameterReturn.test(12,10);
        System.out.println(ret);
    }
    public static void main2(String[] args) {
        // Lambda表达式的使用，和内名内部类式一样的，代码更简单
        /*()的意思是有一个接口，它里面有一个方法，并且下面这个类实现了这个接口，重写了这个方法*/
        NoparameterNoReturn noparameterNoReturn = ()->System.out.println("hello");
        noparameterNoReturn.test();
        //当只有一个参数的时候，（）中可以省略参数的类型  甚至连参数的（）都可以省略
        OneParameterNoReturn oneParameterNoReturn = (x)-> System.out.println(x+1);
        oneParameterNoReturn.test(12);
        //类型可以一起省略，但是不能只省略一个
        MoreParameterNoReturn moreParameterNoReturn = (x,y)-> System.out.println(x+y);
        moreParameterNoReturn.test(13,24);
    }
    public static void main1(String[] args) {
        NoparameterNoReturn noParameterNoReturn = new NoparameterNoReturn() {
            @Override
            public void test() {
                System.out.println("hello");
            }
        };
        noParameterNoReturn.test();
    }
}
